/**
 * 6种操作：
 * 插入
 * 删除
 * 给定键值x查询排名
 * 给定排名x查询权值
 * 前驱
 * 后继
 * 
 * 支持相同键值，PBDStree可实现
 */
#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>

using llt = long long;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vll = vector<llt>;

template<typename T>
void input(vector<T>&v, int n){
    v.assign(n + 1, {});
    for(int i=1;i<=n;++i) cin >> v[i];
}

template<typename T>
istream & operator >> (istream & is, vector<T> & v){
    for(auto & i : v) is >> i;
    return is;
}

llt const INF = 0x1F2F3F4F5F6F7F8F;
llt const NINF = -INF;
llt const MOD = 1000000;


struct PBDS_BST{ // pbds的红黑树实现二叉排序树

using T = int;
using key_t = pair<T, int>; // 加时间戳，可以处理相同的键值
using value_t = int;

__gnu_pbds::tree<
    key_t, value_t, std::less<key_t>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update
>shu;

/// 插入键值对，k是键，timestamp是时间戳
void insert(const T & k, int timestamp, const value_t & v = 0){
    this->shu.insert({{k, timestamp}, v});
}

/// 删除键，保证k至少存在一个
void erase(const T & k){
    auto it = this->shu.lower_bound({k, 0});
    assert(it->first.first == k);
    this->shu.erase(it);
}

/// 查询k在树中的排名，最小的数排名为1
/// k可以不存在于树中，此时为假设k在树中的排名
/// 假设k存在于树中，令time为负数，则返回第一个k在树中的排名
/// time为无穷大则返回最后一个k在树中的排名
int rank(const T & k, int time)const{
    auto ret = this->shu.order_of_key({k, time});
    return ret + 1;
}

/// 取出排名为第sn的键，最小的数为第1名
T select(int sn)const{
    assert(0 < sn && sn <= this->shu.size());
    auto it = this->shu.find_by_order(sn - 1);
    return it->first.first;
}

/// 求k的前驱，即比k小的最大的键，保证有
T pred(const T & k)const{
    auto it = this->shu.lower_bound({k, 0});
    assert(it != this->shu.begin());
    --it;
    return it->first.first;
}

/// 求k的后继，即比k大的最小的键，保证有
/// 需要传一个比目前时间戳更大的数
T succ(const T & k, int largestStamp = INT32_MAX)const{
    auto it = this->shu.upper_bound({k, largestStamp});
    assert(it != this->shu.end());
    return it->first.first;
}

int size()const{return this->shu.size();}

/// 返回最小值，保证树不为空
T min()const{return this->shu.begin()->first.first;}

/// 返回最大值，保证树不为空
T max()const{return (--this->shu.end())->first.first;}

}Tree;



void work(){
    int Q; cin >> Q;

	for(int cmd,x,q=1;q<=Q;++q){
        cin >> cmd >> x;
		switch(cmd){
			case 1:{
				Tree.insert(x, q);
				break;
			}
			case 2:{
				Tree.erase(x);
				break;
			}
			case 3:{
				auto ans = Tree.rank(x, 0);
				cout << ans << "\n";
				break;
			}
			case 4:{
				auto ans = Tree.select(x);
				cout << ans << "\n";
				break;
			}
			case 5:{
                auto ans = Tree.pred(x);
				cout << ans << "\n";
				break;
			}
			case 6:{
                auto ans = Tree.succ(x);
				cout << ans << "\n";
				break;
			}
            default: assert(0);
		} 
	}

    return;
}


int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int nofkase = 1;
    // cin >> nofkase; 
    while(nofkase--) work();    
    return 0;
}
